//package com.yangchuang.openpicture.service.impl;
//
//import com.yangchuang.openpicture.constant.RedisConstants;
//import com.yangchuang.openpicture.service.PictureService;
//import com.yangchuang.openpicture.service.UserActionRedisService;
//import com.yangchuang.openpicture.service.UserFavoriteFolderService;
//import com.yangchuang.openpicture.service.UserStatsUpdateBuilder;
//import com.yangchuang.openpicture.util.RedisUtils;
//import com.yangchuang.openpicture.util.ShanghaiTimeUtils;
//import lombok.RequiredArgsConstructor;
//import lombok.extern.slf4j.Slf4j;
//import org.springframework.stereotype.Service;
//
//import java.util.HashMap;
//import java.util.Map;
//import java.util.concurrent.TimeUnit;
//
//import static com.yangchuang.openpicture.util.ShanghaiTimeUtils.getCurrentTimeStr;
//
//@Slf4j
//@Service
//@RequiredArgsConstructor
//public class UserActionRedisServiceImpl implements UserActionRedisService {
//
//    private final RedisUtils redisUtils;
//    private final PictureService pictureService;
//    private final UserFavoriteFolderService userFavoriteFolderService;
//
//    // ========== 点赞行为 ==========
//
//
//    /**
//     * 通过判断user_like_picture的set集合中是否有这张图片，以此判断用户是不是第一次和这张图片发生“关系”
//     *
//     * @param userId    用户id
//     * @param pictureId 喜欢的图片的id
//     * @return 是否包含
//     */
//
//
//
//
//
//
//
//
//    //多一个收藏夹
////    @Override
////    public void userFavoritePictureHashInit(Long userId, Long pictureId, Long folderId) {
////        Map<String, Object> user_favorite_picture_hash = new HashMap<>();
////        //现在的时间
////        String currentTimeStr = ShanghaiTimeUtils.getCurrentTimeStr();
////        user_favorite_picture_hash.put(RedisConstants.USER_FAVORITE_PICTURE_HASH_FIELD_CREATE_TIME, currentTimeStr);
////        user_favorite_picture_hash.put(RedisConstants.USER_FAVORITE_PICTURE_HASH_FIELD_UPDATE_TIME, currentTimeStr);
////        //喜欢某张图片 状态字段设置为1
////        user_favorite_picture_hash.put(RedisConstants.USER_LIKE_PICTURE_HASH_FIELD_STATUS, 1);
////        //多一个设置收藏夹的动作
////        user_favorite_picture_hash.put(RedisConstants.USER_FAVORITE_PICTURE_HASH_FIELD_FOLDER_ID, folderId);
////        redisUtils.hash().addBatch(RedisConstants.USER_FAVORITE_PICTURE_HASH + userId + ":" + pictureId, user_favorite_picture_hash);
////        //对应的收藏夹下面的图片 数量+1 且 设置这个文件夹 用户肯定只能把图片收藏到已经存在的收藏夹
////        //这里不用和其它的判断是否存在 因为必须存在
////        String key = RedisConstants.FAVORITE_FOLDER_HASH + folderId;
////        //更新时间 和 这个文件夹下面的图片的数量 folder_name user_id 和 创建时间 不变
////        redisUtils.hash().modifyField(key, RedisConstants.FAVORITE_FOLDER_HASH_FIELD_UPDATE_TIME, currentTimeStr);
////        redisUtils.hash().incrBy(key, RedisConstants.FAVORITE_FOLDER_HASH_FIELD_PICTURE_NUMBER, 1);
////    }
//
//
//    //初始化完整版  哪个行为出发了对于这张图片的记录
//    //为了后面调用的方便 只传对应的那个  只判断某个字段是否为null 就可以 不是触发原因的，根本不传，就是null
////    @Override
////    public void PictureStatsHashInit(Long pictureId, Boolean isLike, Boolean isFavorite, Boolean isComment, Boolean isDownload) {
////        Map<String, Object> picture_stats_hash = new HashMap<>();
////        picture_stats_hash.put(RedisConstants.PICTURE_STATS_HASH_FIELD_COMMENTS_COUNT, isComment != null ? 1 : 0);
////        picture_stats_hash.put(RedisConstants.PICTURE_STATS_HASH_FIELD_LIKES_COUNT, isLike != null ? 1 : 0);
////        picture_stats_hash.put(RedisConstants.PICTURE_STATS_HASH_FIELD_VIEWS_COUNT, 1);
////        picture_stats_hash.put(RedisConstants.PICTURE_STATS_HASH_FIELD_FAVORITES_COUNT, isFavorite != null ? 1 : 0);
////        picture_stats_hash.put(RedisConstants.PICTURE_STATS_HASH_FIELD_DOWNLOADS_COUNT, isDownload != null ? 1 : 0);
////        picture_stats_hash.put(RedisConstants.PICTURE_STATS_HASH_FIELD_UPDATE_TIME, getCurrentTimeStr());
////        //得分字段后面使用定时任务计算更新
////        picture_stats_hash.put(RedisConstants.PICTURE_STATS_HASH_FIELD_SCORE, 0.0);
////        redisUtils.hash().addBatch(RedisConstants.PICTURE_STATS_HASH + pictureId, picture_stats_hash);
////    }
//
//
////    @Override
////    public void toggleLike(Long userId, Long pictureId, Boolean isLike) {
////        //1.user_like_picture的两个结构
////        // set里面 key:user_id   set:喜欢的图片的id(支持自动去重，重复的添加不进去) 这里的key直接区分到user级别就可以
////        boolean result = hasUserEverLikedPicture(userId, pictureId);
////        //不管这个result是啥 我们都可以把pictureId加进去 因为set支持自动去重 通常这种做法更加推荐
////        redisUtils.set().add(RedisConstants.USER_LIKE_PICTURE_SET + userId, String.valueOf(pictureId));
////        String key = RedisConstants.USER_LIKE_PICTURE_HASH + userId + ":" + pictureId;
////        //接下来判断是否存在
////        if (result) {
////            //存在 不是第一次 只需要修改几个状态 更新时间的值即可
////            redisUtils.hash().modifyField(key, RedisConstants.USER_LIKE_PICTURE_HASH_FIELD_STATUS, isLike ? 1 : 0);
////            //更新update_time
////            redisUtils.hash().modifyField(key, RedisConstants.USER_LIKE_PICTURE_HASH_FIELD_UPDATE_TIME, getCurrentTimeStr());
////        } else {
////            //不存在 第一次 先创建 然后赋值 抽象成一个方法 只能是第一次喜欢  不可能是第一次不喜欢
////            userLikePictureHashInit(userId, pictureId);
////        }
////        //2.picture_stats结构
////        PictureStatsHashUpdate(pictureId, isLike, null, null, null);
////        //3.根据picture_id 去查出对应的图片主人的id  先去redis  然后mysql  然后添加到redis
////        String ownerId = PictureOwnerUpdate(pictureId);
////        //4.维护user_stats结构  现在是用户主动喜欢/不喜欢某张 不是被动的
////        new UserStatsUpdateBuilder(this, userId)
////                //不管是主动喜欢或者不喜欢某张图片 浏览量肯定都+1
////                .setLike(isLike).setView(true).execute();
////        // UserStatsHashUpdate(String.valueOf(userId), null, null, null, null, null, null, isLike, null, null, null, null, null, null);
////    }
////
////
////    @Override
////    public void toggleFavorite(Long userId, Long pictureId, Long folderId, Boolean isFavorite) {
////        //1.user_favorite_picture的两个结构
////        // set里面 key:user_id   set:收藏的图片的id(支持自动去重，重复的添加不进去) 这里的key直接区分到user级别就可以
////        boolean result = hasUserEverFavoritedPicture(userId, pictureId);
////        //不管这个result是啥 我们都可以把pictureId加进去 因为set支持自动去重 通常这种做法更加推荐
////        redisUtils.set().add(RedisConstants.USER_FAVORITE_PICTURE_SET + userId, String.valueOf(pictureId));
////        String key = RedisConstants.USER_FAVORITE_PICTURE_HASH + userId + ":" + pictureId;
////        //接下来判断是否存在
////        if (result) {
////            //存在 不是第一次 只需要修改几个状态 更新时间的值即可
////            redisUtils.hash().modifyField(key, RedisConstants.USER_FAVORITE_PICTURE_HASH_FIELD_STATUS, isFavorite ? 1 : 0);
////            //更新update_time
////            redisUtils.hash().modifyField(key, RedisConstants.USER_FAVORITE_PICTURE_HASH_FIELD_UPDATE_TIME, getCurrentTimeStr());
////            //我们这里默认 不允许移动 想要移动 只能取消 然后重新添加收藏
////            //对应收藏夹的状态也要进行更新
////            String folderKey = RedisConstants.FAVORITE_FOLDER_HASH + folderId;
////            //更新时间 和 这个文件夹 下面的图片的数量 folder_name user_id 和 创建时间 不变
////            redisUtils.hash().modifyField(folderKey, RedisConstants.FAVORITE_FOLDER_HASH_FIELD_UPDATE_TIME, getCurrentTimeStr());
////            redisUtils.hash().incrBy(folderKey, RedisConstants.FAVORITE_FOLDER_HASH_FIELD_PICTURE_NUMBER, isFavorite ? 1 : -1);
////        } else {
////            //不存在 第一次 先创建 然后赋值 抽象成一个方法 只能是第一次收藏 不可能是第一次取消收藏
////            userFavoritePictureHashInit(userId, pictureId, folderId);
////        }
////
////        //2.picture_stats结构
////        PictureStatsHashUpdate(pictureId, null, isFavorite, null, null);
////        //3.根据picture_id 去查出对应的图片主人的id  先去redis  然后mysql  然后添加到redis
////        String ownerId = PictureOwnerUpdate(pictureId);
////        //4.维护user_stats结构  现在是用户主动收藏/取消收藏某张 不是被动的
////        new UserStatsUpdateBuilder(this, userId)
////                .setFavorite(isFavorite).setView(true).execute();
////    }
//
//    //全能版
////    @Override
////    public void UserStatsHashUpdate(Long userId, Boolean liked, Boolean favorited, Boolean commented, Boolean followed, Boolean viewed, Boolean downloaded, Boolean like, Boolean favorite, Boolean comment, Boolean follow, Boolean download, Boolean view, Boolean publish) {
////        //维护这个主播的各项数据
////        String key = RedisConstants.USER_STATS_HASH + userId;
////        boolean exists = redisUtils.hash().exists(key);
////        if (!exists) {
////            //不存在 则初始化
////            UserStatsHashInit(userId, liked, favorited, commented, followed, viewed, downloaded, like, favorite, comment, follow, download, view);
////        }
////        // 存在时，更新相应的字段值（仅处理非null参数）
////        // 被动作相关统计（他人对当前用户的操作）
////        if (followed != null) {
////            redisUtils.hash().incrBy(key, RedisConstants.USER_STATS_HASH_FIELD_GET_FANS_COUNT, followed ? 1 : -1);
////        }
////        if (liked != null) {
////            redisUtils.hash().incrBy(key, RedisConstants.USER_STATS_HASH_FIELD_GET_TOTAL_LIKES, liked ? 1 : -1);
////        }
////        if (favorited != null) {
////            redisUtils.hash().incrBy(key, RedisConstants.USER_STATS_HASH_FIELD_GET_TOTAL_FAVORITES, favorited ? 1 : -1);
////        }
////        if (commented != null) {
////            redisUtils.hash().incrBy(key, RedisConstants.USER_STATS_HASH_FIELD_GET_TOTAL_COMMENTS, commented ? 1 : -1);
////        }
////        if (downloaded != null) {
////            redisUtils.hash().incrBy(key, RedisConstants.USER_STATS_HASH_FIELD_GET_TOTAL_DOWNLOADS, downloaded ? 1 : -1);
////        }
////
////        // 主动作相关统计（当前用户对他人的操作）
////        if (follow != null) {
////            redisUtils.hash().incrBy(key, RedisConstants.USER_STATS_HASH_FIELD_OWN_FOLLOWING_COUNT, follow ? 1 : -1);
////        }
////        if (favorite != null) {
////            redisUtils.hash().incrBy(key, RedisConstants.USER_STATS_HASH_FIELD_OWN_FAVORITES_COUNT, favorite ? 1 : -1);
////        }
////        if (download != null) {
////            redisUtils.hash().incrBy(key, RedisConstants.USER_STATS_HASH_FIELD_OWN_DOWNLOADS_COUNT, download ? 1 : -1);
////        }
////
////        if (comment != null) {
////            redisUtils.hash().incrBy(key, RedisConstants.USER_STATS_HASH_FIELD_OWN_TOTAL_COMMENTS_COUNT, comment ? 1 : -1);
////        }
////        if (like != null) {
////            redisUtils.hash().incrBy(key, RedisConstants.USER_STATS_HASH_FIELD_OWN_LIKES_COUNT, like ? 1 : -1);
////        }
////        if (publish != null) {
////            redisUtils.hash().incrBy(key, RedisConstants.USER_STATS_HASH_FIELD_OWN_TOTAL_WORKS_COUNT, publish ? 1 : -1);
////
////        }
////        //下面这两个字段，除非是不存在去初始化的时候，不然的话，不管是哪个行为出发了用户的统计数据更新，
////        //都至少有一个为true
////        if (viewed != null) {
////            redisUtils.hash().incrBy(key, RedisConstants.USER_STATS_HASH_FIELD_GET_TOTAL_VIEWS, viewed ? 1 : -1);
////        }
////
////        if (view != null) {
////            redisUtils.hash().incrBy(key, RedisConstants.USER_STATS_HASH_FIELD_OWN_VIEWS_COUNT, view ? 1 : -1);
////        }
////        // 特殊字段：更新时间（记录初始化时间戳）
////        redisUtils.hash().modifyField(key, RedisConstants.USER_STATS_HASH_FIELD_UPDATE_TIME, getCurrentTimeStr());
////    }
////
////    //因为什么原因被初始化 全能版
////    @Override
////    public void UserStatsHashInit(Long userId, Boolean liked, Boolean favorited, Boolean commented, Boolean followed, Boolean viewed, Boolean downloaded, Boolean like, Boolean favorite, Boolean comment, Boolean follow, Boolean download, Boolean view) {
////        //不存在 初始化 判断是因为啥动作触发了初始化
////        String key = RedisConstants.USER_STATS_HASH + userId;
////
////        Map<String, Object> user_stats_hash = new HashMap<>();
////        // 被动作相关统计（他人对当前用户的操作）
////        user_stats_hash.put(RedisConstants.USER_STATS_HASH_FIELD_GET_FANS_COUNT, followed != null ? 1 : 0); // 粉丝数（因被关注触发）
////        user_stats_hash.put(RedisConstants.USER_STATS_HASH_FIELD_GET_TOTAL_LIKES, liked != null ? 1 : 0); // 总被点赞数（因被点赞触发）
////        user_stats_hash.put(RedisConstants.USER_STATS_HASH_FIELD_GET_TOTAL_FAVORITES, favorited != null ? 1 : 0); // 总被收藏数（因被收藏触发）
////        user_stats_hash.put(RedisConstants.USER_STATS_HASH_FIELD_GET_TOTAL_COMMENTS, commented != null ? 1 : 0); // 总被评论数（因被评论触发）
////        user_stats_hash.put(RedisConstants.USER_STATS_HASH_FIELD_GET_TOTAL_VIEWS, viewed != null ? 1 : 0); // 总被浏览数（因被浏览触发）
////        user_stats_hash.put(RedisConstants.USER_STATS_HASH_FIELD_GET_TOTAL_DOWNLOADS, downloaded != null ? 1 : 0); // 总被下载数（因被下载触发）
////
////        // 主动作相关统计（当前用户对他人的操作）
////        user_stats_hash.put(RedisConstants.USER_STATS_HASH_FIELD_OWN_FOLLOWING_COUNT, follow != null ? 1 : 0); // 自己关注数（因主动关注触发）
////        user_stats_hash.put(RedisConstants.USER_STATS_HASH_FIELD_OWN_FAVORITES_COUNT, favorite != null ? 1 : 0); // 自己收藏数（因主动收藏触发）
////        user_stats_hash.put(RedisConstants.USER_STATS_HASH_FIELD_OWN_DOWNLOADS_COUNT, download != null ? 1 : 0); // 自己下载数（因主动下载触发）
////        user_stats_hash.put(RedisConstants.USER_STATS_HASH_FIELD_OWN_VIEWS_COUNT, view != null ? 1 : 0); // 自己浏览数（因主动浏览触发）
////        user_stats_hash.put(RedisConstants.USER_STATS_HASH_FIELD_OWN_TOTAL_COMMENTS_COUNT, comment != null ? 1 : 0); // 自己评论数（因主动评论触发）
////        user_stats_hash.put(RedisConstants.USER_STATS_HASH_FIELD_OWN_LIKES_COUNT, like != null ? 1 : 0); // 自己点赞数（因主动点赞触发）
////
////        // 特殊字段：自己的作品总数（初始化默认为0，与动作触发无关）
////        user_stats_hash.put(RedisConstants.USER_STATS_HASH_FIELD_OWN_TOTAL_WORKS_COUNT, 0);
////
////        // 特殊字段：更新时间（记录初始化时间戳）
////        user_stats_hash.put(RedisConstants.USER_STATS_HASH_FIELD_UPDATE_TIME, getCurrentTimeStr());
////        redisUtils.hash().addBatch(key, user_stats_hash);
////    }
//
//
//    @Override
//    public String PictureOwnerUpdate(Long pictureId) {
//        //1.先去redis里面查
//        String key = RedisConstants.PICTURE_OWNER_STRING + pictureId;
//        boolean exists = redisUtils.string().exists(key);
//        if (!exists) {
//            Long pictureOwnerId = pictureService.getPictureOwnerIDByPictureID(pictureId);
//            if (pictureOwnerId != null) {
//                //存入redis里面
//                redisUtils.string().addWithTTL(key, String.valueOf(pictureOwnerId), RedisConstants.PICTURE_OWNER_TTL_SECONDS, TimeUnit.SECONDS);
//            }
//            return String.valueOf(pictureOwnerId);
//        }
//        //存在 直接return
//        return redisUtils.string().getValueByKey(key);
//    }
//
//
//    //todo  进一步完善什么东西？？ 比较 更新时间和上一次计算的时间 如果更新时间大于上一次计算的时候 则要加入脏数据的set中（picture_id）
//    @Override
//    public void PictureStatsHashUpdate(Long pictureId, Boolean isLike, Boolean isFavorite, Boolean isComment, Boolean isDownload) {
//        //去找有没有 放的时候怎么放 找的时候就怎么找
//        String key = RedisConstants.PICTURE_STATS_HASH + pictureId;
//        boolean exists = redisUtils.hash().exists(key);
//
//        // 存在 喜欢 +1 +1
//        // 存在 不喜欢 -1 -1
//        //浏览量 永远增加 就算是不喜欢 也浏览了
//        if (exists) {
//            //存在 已经在redis里面了 则更新相关的数据就好
//            //不管是哪种行为出发了 浏览量肯定都+1
//            redisUtils.hash().incrBy(key, RedisConstants.PICTURE_STATS_HASH_FIELD_VIEWS_COUNT, 1);
//            //更新时间
//            redisUtils.hash().modifyField(key, RedisConstants.PICTURE_STATS_HASH_FIELD_UPDATE_TIME, getCurrentTimeStr());
//            //喜欢数量 isLike==null 说明用户没有操作喜欢/取消 islike!=null :true 喜欢了，fasle:取消了喜欢
//            //isLike==null do nothing 这样子的话 就要做很多判断
//            if (isLike != null) {
//                redisUtils.hash().incrBy(key, RedisConstants.PICTURE_STATS_HASH_FIELD_LIKES_COUNT, isLike ? 1 : -1);
//            }
//            //收藏数量
//            if (isFavorite != null) {
//                redisUtils.hash().incrBy(key, RedisConstants.PICTURE_STATS_HASH_FIELD_LIKES_COUNT, isFavorite ? 1 : -1);
//            }
//            //下载数量
//            if (isComment != null) {
//                redisUtils.hash().incrBy(key, RedisConstants.PICTURE_STATS_HASH_FIELD_LIKES_COUNT, isComment ? 1 : -1);
//            }
//            //评论数量
//            if (isDownload != null) {
//                redisUtils.hash().incrBy(key, RedisConstants.PICTURE_STATS_HASH_FIELD_LIKES_COUNT, isDownload ? 1 : -1);
//            }
//            //存在 且被出发了 则说明浏览量肯定+1
//            redisUtils.hash().incrBy(key, RedisConstants.PICTURE_STATS_HASH_FIELD_VIEWS_COUNT, 1);
//        } else {
//            // 不存在
//            // 某种行为触发了初始化
//            PictureStatsHashInit(pictureId, isLike, isFavorite, isComment, isDownload);
//        }
//        //不存在 （代表之前从没有用户 喜欢/不喜欢过这张图片） 不喜欢 用户不可能去接取消自己的喜欢 互相矛盾了
//    }
//
//
//    // ========== 图片统计 ==========
//
//
//
//
//    // ========== 浏览/下载 ==========
//
//    @Override
//    public void UserDownloadPicture(Long userId, Long pictureId) {
//        //涉及： user本人 图片状态 被下载的图片的主人的user_统计
//        //1.下载这张图片的人
//        new UserStatsUpdateBuilder(this, userId)
//                .setDownload(true).setView(true).execute();
//        //2.这张图片的状态
//        this.PictureStatsHashUpdate(pictureId,
//                null,
//                null,
//                null
//                , true);
//        //3.找到这张图片的主人
//        String picturedOwnerId = PictureOwnerUpdate(pictureId);
//        //4.更新这个主人的数据信息
//        new UserStatsUpdateBuilder(this, userId)
//                //图片的主人的下载量+1  但是别忘了被浏览量肯定也+1
//                .setDownloaded(true).setViewed(true).execute();
//    }
//
//    //用户浏览某张图片
//    @Override
//    public void UserViewPicture(Long userId, Long pictureId) {
//        //涉及： user本人 图片状态 被下载的图片的主人的user_统计
//        //1.下载这张图片的人
//        new UserStatsUpdateBuilder(this, userId)
//                .setView(true).execute();
//        //2.这张图片的状态 没有特定的行为 只有点开浏览 方法里面已经包含这个维护了
//        this.PictureStatsHashUpdate(pictureId,
//                null,
//                null,
//                null
//                , null);
//        //3.找到这张图片的主人
//        String picturedOwnerId = PictureOwnerUpdate(pictureId);
//        //4.更新这个主人的数据信息
//        new UserStatsUpdateBuilder(this, userId)
//                //图片的主人 主动浏览量 +1
//                .setView(true).execute();
//    }
//
//
//}